# 1 "sys_video.c"
# 1 "/home/diego/sodium/kernel//"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "sys_video.c"
# 1 "../include/kernel/puertos.h" 1







# 1 "../include/kernel/definiciones.h" 1
# 14 "../include/kernel/definiciones.h"
# 1 "../include/usr/tipos.h" 1
# 15 "../include/usr/tipos.h"
typedef unsigned int dword;
typedef unsigned short word;
typedef unsigned char byte;

typedef unsigned char u8;
typedef signed char s8;
typedef unsigned short u16;
typedef signed short s16;
typedef unsigned int u32;
typedef signed int s32;


typedef struct _u80 { unsigned int word[20]; } u80;
# 15 "../include/kernel/definiciones.h" 2
# 62 "../include/kernel/definiciones.h"
char stArgAux[128];
# 9 "../include/kernel/puertos.h" 2
# 26 "../include/kernel/puertos.h"
byte inb(word);
# 38 "../include/kernel/puertos.h"
word inw(word);
# 50 "../include/kernel/puertos.h"
void outb(const byte valor, const word puerto);
# 61 "../include/kernel/puertos.h"
void outw(const word valor, const word puerto);
# 2 "sys_video.c" 2
# 1 "../include/shell/sys_video.h" 1







# 1 "../include/video.h" 1
# 14 "../include/video.h"
# 1 "../include/kernel/libk/string.h" 1
# 9 "../include/kernel/libk/string.h"
inline unsigned char* ucpFnCopiarMemoria(unsigned char *ucpDestino,
      unsigned char *ucpOrigen,
      unsigned int uiTamanio);
inline unsigned char* ucpFnMemSetCero(unsigned char *ucpDirInicio,
                  unsigned int uiTamanio );

int iFnLongitudCadena (const char *cnstCadena);
int iFnCompararCadenas (const char *, const char *);
int iFnCompararCadenas2 (const char *, const char *);
int iFnCopiaCaracter (char *, const char *);
int iFnCopiaCadena (char *, const char *);

int iFnCopiaEntero (char *, const int);
int iFnCopiaFloat (char *, const float, const int);
int iFnCopiaWord (char *, const word);
int iFnCopiaByte (char *, const byte);
int iFnCopiaHexa (char *, const int);
int iFnCopiaWordHexa (char *, const word);
int iFnCopiaByteHexa (char *, const byte);
void vFnImprimirString (char *, const char *, ...);
int iFnLongitudCadena (const char *);

int iFnCopiaCadena2 (char *, const char *);
char * pstFnConcatenarCadena (char * , char * );
int iFnBuscarEnCadena (char * , char * ,int );
char * pstFnCadenaIzquierda (char * , int );
char * pstFnCadenaDerecha (char * , int );
int iFnEsNumero (char * stCadena);

void vFnStrLwr (char * stCadena);
void vFnStrUpr (char * stCadena);
# 15 "../include/video.h" 2
# 58 "../include/video.h"
typedef char* va_list;
# 100 "../include/video.h"
int iFnImprimirCadenas (int,const char*);




void vFnImprimirEntero (int,const int);




void vFnImprimirFloat (int,const double, const int);




void vFnImprimirHexa (int,const int);




void vFnImprimirWordHexa (int,const word);




void vFnImprimirByteHexa (int,const byte);





void vFnImprimirWin (int,const char*, ... );
void vFnImprimir (const char*, ... );
void vFnImprimirI (const char*, ... );

extern char cFnSysObtenerColor(int);
extern void vFnSysSetearColor(int,char);
extern void vFnSysSetearX(int,int);
extern void vFnSysSetearY(int,int);
extern void vFnClsWin(int);





void vFnImprimirContextSwitch(int color,int pid, char* nombre, int indiceGDT);
void vFnImprimirPrompt();
void vFnImprimirOk(int linea);
void vFnImprimirNOk(int linea);

void vFnImprimirVentana (int hVentana, const char *cnstCadena, ...);






int bTerminalActiva;

void vFnCambiarTerminal(void);
void vFnLog (const char *cnstCadena, ...);

void vFnLogScrollArriba();
void vFnLogScrollAbajo();

void vFnLogScrollMaximo();
void vFnLogScrollMinimo();
void vFnLogBorrar();
# 9 "../include/shell/sys_video.h" 2
# 21 "../include/shell/sys_video.h"
typedef struct _stuVentana_
{
  int iCursorX;
  int iCursorY;
  char cColor;
  int iPosicionX;
  int iPosicionY;
  int iAncho;
  int iAlto;
}stuVentana;

void vFnTabulador (int);
void vFnNuevaLinea (int);
void vFnBorrarCaracter (int);
void vFnScroll (int);
inline void vFnPonerCaracter (int, int);
char cFnObtenerColor (int);
void vFnSysSetearColor (int, char);
void vFnSysSetearX (int, int);
void vFnSysSetearY (int, int);
void vFnCambiarVisibilidadVentanaProceso ();
void vFnClsWin (int);
# 3 "sys_video.c" 2
# 1 "../include/shell/teclado.h" 1
# 509 "../include/shell/teclado.h"
char stBufferShell[256];

char stBufferTeclado[10];






struct _stuKeyCode {
    unsigned char tipo;
    unsigned char ascii;
};

typedef struct _stuKeyCode stuKeyCode;




struct _stuDefinicionTeclado {
    char sCodigo [5];
    char sNombre [25];
    stuKeyCode stashMatrizNormal [128];
    stuKeyCode stashMatrizShifted [128];
    stuKeyCode stashMatrizAltGred [128];
} __attribute__((packed));

typedef struct _stuDefinicionTeclado stuDefinicionTeclado;


void vFnManejadorTecladoShell (unsigned char ucScanCode);
void vFnScanCodeAKeyCode( stuKeyCode*, unsigned char );
void vFnScanCodeExtAKeyCode( stuKeyCode*, unsigned char );
void vFnKeyCodeNumPad( stuKeyCode* );
int iFnTeclaEspecial ( stuKeyCode, unsigned char );
int iFnCombinacionTeclasEspecial( stuKeyCode );
void * pvFnAbrirArchivoKeymap (void);
int iFnCambiaTecladoI(unsigned int);
int iFnCambiaTecladoS(char *);
void vFnListarKeymaps();
char cFnGetChar();
char cFnPausa();

int iCantidadCaracteres;
int iSemaforoBufferTeclado;
int iLlenarIndice;
static int staiVaciarIndice;
# 4 "sys_video.c" 2

char* stMemoriaVideo = (char *)0xB8000;
stuVentana pstuVentana[10] = {
  {0, 0, 7, 0, 7, 80, 16},
  {0, 0, 11, 0, 0, (62 - 1), 1},
  {0, 0, 14, 0, 24, 80, 1},
  {0, 0, 13, 0, 2, 80, 4},
  {0, 0, 11, 0, 1, 80, 1},
  {0, 0, 13, 0, 6, 80, 1},
  {0, 0, 14, 0, 23, 80, 1},
  {0, 0, 15, 62, 0, 18, 1},
  {0, 0, 7, 0, 25, 80, 23},
  {0, 0, 14, 0,48, 80, 2}
};

byte bBufferLog[(25 +1+1)*160];

static word wIndexLog=0;
static word wLecturaLog=0;
# 35 "sys_video.c"
int
iFnSysImprimirCaracter (int iHwnd, char cCaracter)
{
  switch (cCaracter)
    {
    case '\b':
      vFnBorrarCaracter (iHwnd);
      break;
    case '\n':
      vFnNuevaLinea (iHwnd);
      break;
    case '\t':
      vFnTabulador (iHwnd);
      break;
    default:
      vFnPonerCaracter (iHwnd, cCaracter);
      vFnIncrementarCoordenadas (iHwnd);
      break;
    }

  if (iHwnd == 0)
    vFnActualizarCursor (0);

  return 1;
}






void
vFnTabulador (int iHwnd)
{
  static int staiIndice;
  static int staiCantidadEspacios;

  int iCursorX = pstuVentana[iHwnd].iCursorX;

  staiCantidadEspacios =
    (((iCursorX / 8) + 1) * 8) - iCursorX;
  for (staiIndice = 0; staiIndice < staiCantidadEspacios; staiIndice++)
    {
      vFnPonerCaracter (iHwnd, ' ');
      vFnIncrementarCoordenadas (iHwnd);
    }
}






void
vFnNuevaLinea (int iHwnd)
{
  pstuVentana[iHwnd].iCursorX = 0;
  if (pstuVentana[iHwnd].iCursorY >= pstuVentana[iHwnd].iAlto - 1)
    vFnScroll (iHwnd);
  else
    pstuVentana[iHwnd].iCursorY++;
}




void
vFnBorrarCaracter (int iHwnd)
{
  if (--pstuVentana[iHwnd].iCursorX == -1)
    {
      if (pstuVentana[iHwnd].iCursorY == 0)
 pstuVentana[iHwnd].iCursorX = 0;
      else
 {
   pstuVentana[iHwnd].iCursorX = pstuVentana[iHwnd].iAncho - 1;
   pstuVentana[iHwnd].iCursorY--;
 }
    }

  vFnPonerCaracter (iHwnd, ' ');

  if (iHwnd == 0)
      vFnActualizarCursor (0);
}




void
vFnScroll (int iHwnd)
{
  int iN, iJ;
  int iPosicionX = pstuVentana[iHwnd].iPosicionX;
  int iPosicionY = pstuVentana[iHwnd].iPosicionY;
  int iAncho = pstuVentana[iHwnd].iAncho;
  int iAlto = pstuVentana[iHwnd].iAlto;


   if( iHwnd == 8 )
   {

      for( iJ=wIndexLog; iJ>=0; iJ-- )
         for( iN=0; iN<160; iN++ )
            bBufferLog[ iN + (iJ*160) ] = bBufferLog[ iN + ((iJ-1)*160) ];


      for (iN = 0; iN <160; iN+=2)
         bBufferLog[ (iN) ] = stMemoriaVideo[(iPosicionX + iN)+(iPosicionY)*160];


      if( wIndexLog <= 25 ) wIndexLog++;
   }


  for (iJ = 1; iJ < iAlto; iJ++)
    {
      for (iN = 0; iN < iAncho; iN++)
 {
   stMemoriaVideo[((iPosicionX + iN) * 2)+(iPosicionY + iJ - 1)*160] =
     stMemoriaVideo[((iPosicionX + iN) * 2)+(iPosicionY + iJ)*160];
   stMemoriaVideo[((iPosicionX + iN) * 2 + 1)+(iPosicionY + iJ - 1)*160] =
     stMemoriaVideo[((iPosicionX + iN) * 2 + 1)+(iPosicionY + iJ)*160];
 }
    }

  for (iN = 0; iN < iAncho; iN++)
    {
      stMemoriaVideo[((iPosicionX + iN) * 2)+(iPosicionY + iAlto - 1)*160] = ' ';
      stMemoriaVideo[((iPosicionX + iN) * 2 + 1)+(iPosicionY + iAlto - 1)*160] =
 pstuVentana[iHwnd].cColor;
    }

  pstuVentana[iHwnd].iCursorX = 0;
  pstuVentana[iHwnd].iCursorY = iAlto - 1;
}
# 183 "sys_video.c"
void
vFnActualizarCursor (int iHwnd)
{
  int iCursorX;
  int iCursorY;

  iCursorX = pstuVentana[iHwnd].iCursorX + pstuVentana[iHwnd].iPosicionX;
  iCursorY = pstuVentana[iHwnd].iCursorY + pstuVentana[iHwnd].iPosicionY;

  outb (0xF, 0x3D4);
  outb ((iCursorY * 80 + iCursorX) & 0x00FF, 0x3D5);
  outb (0xE, 0x3D4);
  outb (0x2, 0x3D5);
  outb (((iCursorY * 80 + iCursorX) >> 8) & 0x00FF, 0x3D5);
}





inline void
vFnIncrementarCoordenadas (int iHwnd)
{
  int iCursorX = pstuVentana[iHwnd].iCursorX;
  int iCursorY = pstuVentana[iHwnd].iCursorY;

  if (++iCursorX == pstuVentana[iHwnd].iAncho)
    {
      if (iCursorY == pstuVentana[iHwnd].iAlto - 1)
 vFnScroll (iHwnd);
      else
 iCursorY++;

      iCursorX = 0;
    }

  pstuVentana[iHwnd].iCursorX = iCursorX;
  pstuVentana[iHwnd].iCursorY = iCursorY;
}






inline void
vFnPonerCaracter (int iHwnd, int iCaracter)
{
  if (pstuVentana[iHwnd].iAlto > 0)
    {
      stMemoriaVideo[((pstuVentana[iHwnd].iPosicionX + pstuVentana[iHwnd].iCursorX) * 2)+(pstuVentana[iHwnd].iPosicionY + pstuVentana[iHwnd].iCursorY)*160] = iCaracter;



      stMemoriaVideo[((pstuVentana[iHwnd].iPosicionX + pstuVentana[iHwnd].iCursorX) * 2 + 1)+(pstuVentana[iHwnd].iPosicionY + pstuVentana[iHwnd].iCursorY)*160] = pstuVentana[iHwnd].cColor;



    }
}






char
cFnObtenerColor (int iHwnd)
{
  return pstuVentana[iHwnd].cColor;
}






void
vFnSysSetearColor (int iHwnd, char cColor)
{
  pstuVentana[iHwnd].cColor = cColor;
}






void
vFnSysSetearX (int iHwnd, int iCursorX)
{
  pstuVentana[iHwnd].iCursorX = iCursorX;
}






void
vFnSysSetearY (int iHwnd, int iCursorY)
{
  pstuVentana[iHwnd].iCursorY = iCursorY;
}






void
vFnClsWin (int iHwnd)
{
  int iN;

  for (iN = 0; iN < pstuVentana[iHwnd].iAlto; iN++)
    vFnImprimirVentana (iHwnd, "\n");

}






void
vFnCambiarVisibilidadVentanaProceso ()
{
  int iN;
  static int staiEstado = 1;
  static stuVentana stastuVentanaShell;
  static stuVentana stastuVentanaProceso;
  static stuVentana stastuSeparadorVentanaProceso;

  if (staiEstado == 1)
    {
      staiEstado = 0;

      vFnClsWin (3);
      vFnClsWin (5);

      stastuVentanaProceso = pstuVentana[3];
      stastuSeparadorVentanaProceso = pstuVentana[5];
      stastuVentanaShell = pstuVentana[0];

      pstuVentana[0].iPosicionY = 2;
      pstuVentana[0].iAlto =
 pstuVentana[0].iAlto + stastuVentanaProceso.iAlto +
 stastuSeparadorVentanaProceso.iAlto;

      pstuVentana[3].iCursorX = 0;
      pstuVentana[3].iCursorY = 0;
      pstuVentana[3].iAlto = 0;
      pstuVentana[3].iAncho = 0;

      pstuVentana[5].iCursorX = 0;
      pstuVentana[5].iCursorY = 0;
      pstuVentana[5].iAlto = 0;
      pstuVentana[5].iAncho = 0;
      for (iN = 0;
    iN <
    (stastuVentanaProceso.iAlto + stastuSeparadorVentanaProceso.iAlto);
    iN++)
 vFnScroll (0);
      pstuVentana[0].iCursorY =
 pstuVentana[0].iCursorY - (stastuVentanaProceso.iAlto +
       stastuSeparadorVentanaProceso.iAlto);
    }
  else
    {
      staiEstado = 1;
      pstuVentana[0].iPosicionY = stastuVentanaShell.iPosicionY;
      pstuVentana[0].iAlto = stastuVentanaShell.iAlto;
      pstuVentana[0].iCursorY =
      pstuVentana[0].iCursorY - (stastuVentanaProceso.iAlto +
       stastuSeparadorVentanaProceso.iAlto);
      pstuVentana[3] = stastuVentanaProceso;
      pstuVentana[5] = stastuSeparadorVentanaProceso;

      vFnClsWin (3);
     }
}







void vFnCambiarTerminal(void)
{
  int iFlags;
  unsigned short int bInterrupcionesHabilitadas = 0;

   __asm__ ("pushf\n pop %%eax": "=a" (iFlags):);


  if (iFlags & 0x200)
    {
      __asm__ ("cli"::);
      bInterrupcionesHabilitadas = 1;
    }

   switch( bTerminalActiva )
   {

    case 0 :
                  bTerminalActiva = 1;
                  outb(0x0C, 0x3D4); outb((0x07D0&0xFF00)>>8 , 0x3D5);
                  outb(0x0D, 0x3D4); outb((0x07D0&0x00FF) , 0x3D5);

                  break;

    case 1:
                  bTerminalActiva = 0;
                  outb(0x0C, 0x3D4); outb(0x00, 0x3D5);
                  outb(0x0D, 0x3D4); outb(0x00, 0x3D5);
               break;
   }

   if (bInterrupcionesHabilitadas)
    __asm__ ("sti"::);
}
# 414 "sys_video.c"
void vFnLogScrollArriba()
{
   byte bN, bJ;
   byte bAuxBuffer[160];
   int iPosicionX = pstuVentana[8].iPosicionX;
   int iPosicionY = pstuVentana[8].iPosicionY;


   if( wIndexLog == 0 ) return;



   if( (wLecturaLog) < wIndexLog )
   {

      for( bN=0; bN < pstuVentana[8].iAncho<<1; bN+=2)
         bAuxBuffer[bN] = stMemoriaVideo[(iPosicionX + bN)+(iPosicionY + pstuVentana[8].iAlto -1)*160];


      for( bJ=pstuVentana[8].iAlto-1; bJ > 0; bJ--)
         for( bN=0; bN < pstuVentana[8].iAncho<<1; bN+=2)
            stMemoriaVideo[(iPosicionX + bN)+(iPosicionY + bJ)*160] = stMemoriaVideo[(iPosicionX + bN)+(iPosicionY + bJ -1)*160];


      for( bN=0; bN < pstuVentana[8].iAncho<<1; bN+=2)
        stMemoriaVideo[(iPosicionX + bN)+(iPosicionY)*160] = bBufferLog[ (bN) + ((wLecturaLog)*160) ];


      for( bN=0; bN < pstuVentana[8].iAncho<<1; bN++)
         bBufferLog[ bN + ((wLecturaLog)*160)] = bAuxBuffer[bN];


      wLecturaLog++;
    }
}







void vFnLogScrollAbajo()
{
   byte bN, bJ;
   byte bAuxBuffer[160];
   int iPosicionX = pstuVentana[8].iPosicionX;
   int iPosicionY = pstuVentana[8].iPosicionY;


   if( wIndexLog == 0 ) return;


   if( wLecturaLog != 0 )
   {

      wLecturaLog--;


      for( bN=0; bN < pstuVentana[8].iAncho<<1; bN+=2 )
         bAuxBuffer[(bN)] = stMemoriaVideo[(iPosicionX + bN)+(iPosicionY)*160];


      for( bJ=0; bJ < pstuVentana[8].iAlto-1; bJ++ )
         for( bN=0; bN < pstuVentana[8].iAncho<<1; bN+=2 )
            stMemoriaVideo[(iPosicionX + bN)+(iPosicionY + bJ)*160] = stMemoriaVideo[(iPosicionX + bN)+(iPosicionY + bJ+1)*160];


      for( bN=0; bN < 160; bN+=2 )
        stMemoriaVideo[(iPosicionX + bN)+(iPosicionY+pstuVentana[8].iAlto-1)*160] =
                                     bBufferLog[ bN + ((wLecturaLog)*160) ];


      for( bN=0; bN < pstuVentana[8].iAncho<<1; bN++ )
         bBufferLog[ bN + ((wLecturaLog)*160)] = bAuxBuffer[bN];

   }
}







void vFnLogScrollMaximo()
{
   int iN;

   for( iN=wIndexLog;iN>=0;iN--)
      vFnLogScrollArriba();
}







void vFnLogScrollMinimo()
{
   int iN;

   for( iN=wLecturaLog;iN>=0;iN--)
      vFnLogScrollAbajo();
}







void vFnLogBorrar()
{
   byte bN, bJ;
   int iPosicionX = pstuVentana[8].iPosicionX;
   int iPosicionY = pstuVentana[8].iPosicionY;


   wIndexLog=0;


   wLecturaLog=0;


   for( bJ=0; bJ < pstuVentana[8].iAlto; bJ++ )
      for( bN=0; bN < pstuVentana[8].iAncho; bN+=2 )
          stMemoriaVideo[(iPosicionX + bN)+(iPosicionY + bJ)*160] = ' ';


   pstuVentana[8].iCursorX = 0;
   pstuVentana[8].iCursorY = 0;
}
